home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / cenvid / xcopy.cmm < prev   
Encoding:
Text File  |  1995-10-13  |  12.0 KB  |  404 lines
  1. /*
  2.  * XCopy.cmm
  3.  *
  4.  * An xcopy script for the CEnvi shell. It does what the DOS xcopy
  5.  * command does.
  6.  */
  7.  
  8. #include "Netware.lib"
  9.  
  10. usage()
  11. {
  12.   printf("Use the XCOPY command to selectively copy groups of files.\n");
  13.   printf("Syntax:\n");
  14.   printf("  XCOPY [drive:][path] filename [drive:][path] filename [/S][/E]\n");
  15.   printf("        [/A][/M][/H][/T][/R][/O]\n");
  16.   printf("where:\n");
  17.   printf("  drive:/path/filename  Specifies the location of the file to copy.\n");
  18.   printf("  drive:/path/filename  Specified the target destination and file name.\n");
  19.   printf("  /S                    Copies non-empty directories and subdirectories.\n");
  20.   printf("  /E                    When used with /S, copies entire tree structure,\n");
  21.   printf("                        including subdirectories even if they are empty.\n");
  22.   printf("  /A                    Copies archived files only, but does not turn\n");
  23.   printf("                        off the attribute bit of the source file.\n");
  24.   printf("  /M                    Copies archived files only and turns off the\n");
  25.   printf("                        attribute bit of the source file.\n");
  26.   printf("  /H                    Allows hidden files to be copied to the\n");
  27.   printf("                        destination and retain their hidden attribute.\n");
  28.   printf("  /T                    Allows system files to be copied to the\n");
  29.   printf("                        destination and retain their system attribute.\n");
  30.   printf("  /R                    Allows read-only files to be copied to the\n");
  31.   printf("                        destination and retain the read-only attribute,\n");
  32.   printf("  /O                    Specifies that any read-only, hidden, or system\n");
  33.   printf("                        files in the destination can be overwritten by\n");
  34.   printf("                        the copy operation.\n");
  35.   exit(EXIT_FAILURE);
  36. }
  37.  
  38. /*---------------------------------------------------------------------------*/
  39.  
  40. recursive = FALSE;
  41. empty = FALSE;
  42. archived_only = FALSE;
  43. turn_off_archived = FALSE;
  44. copy_hidden = FALSE;
  45. copy_system = FALSE;
  46. copy_readonly = FALSE;
  47. overwrite = FALSE;
  48. source = "";
  49. target = "";
  50.  
  51.  
  52. parse_command_line(argc,argv)
  53. {
  54.   for( i=1;i<argc;i++ )
  55.     {
  56.       if( argv[i][0]=='-' || argv[i][0]=='/' )
  57.         {
  58.           switch( toupper(argv[i][1]) )
  59.             {
  60.             default: usage(); exit(1);
  61.             case 'S': recursive = TRUE; break;
  62.             case 'E': empty = TRUE;
  63.             case 'M': turn_off_archived = TRUE; // intentional fall-thru
  64.             case 'A': archived_only = TRUE; break;
  65.             case 'H': copy_hidden = TRUE; break;
  66.             case 'T': copy_system = TRUE; break;
  67.             case 'R': copy_readonly = TRUE; break;
  68.             case 'O': overwrite = TRUE; break;
  69.             }
  70.           continue;
  71.         }
  72. // Else here we have a filename
  73.       if( source[0]=='\0' )
  74.         {
  75.           strcpy(source,argv[i]);
  76.           continue;
  77.         }
  78.       if( target[0]=='\0' )
  79.         {
  80.           strcpy(target,argv[i]);
  81.           continue;
  82.         }
  83.       printf("You may not specify more than one source or target.\n");
  84.       exit(1);
  85.     }
  86.   if( source[0]=='\0' )
  87.     {
  88.       printf("No source file specified.\n");
  89.       exit(1);
  90.     }
  91.   if( target[0]=='\0' )
  92.     {
  93.       printf("No target directory specified.\n");
  94.       exit(1);
  95.     }
  96. }
  97.  
  98. /*---------------------------------------------------------------------------*/
  99.  
  100. DOSTimeFromCalendar(time)
  101. {
  102.   dos = DOSTimeStructFromCalendar(time);
  103.   return dos.time<<16 | dos.date;
  104. }
  105.  
  106. DOSTimeStructFromCalendar(time)
  107. {
  108.   tm = localtime(time);
  109.   dos.time = (tm.tm_sec/2) | (tm.tm_min<<5) | (tm.tm_hour<<11);
  110.   dos.date = tm.tm_mday | ((tm.tm_mon+1)<<5) | ((tm.tm_year-80)<<9);
  111.   return dos;
  112. }
  113.  
  114. GMDOSTimeStructFromCalendar(time)
  115. {
  116.   tm = gmtime(time);
  117.   dos.time = (tm.tm_sec/2) | (tm.tm_min<<5) | (tm.tm_hour<<11);
  118.   dos.date = tm.tm_mday | ((tm.tm_mon+1)<<5) | ((tm.tm_year-80)<<9);
  119.   return dos;
  120. }
  121.  
  122.  
  123. /*
  124.  * Some DOS functions
  125.  */
  126. SetFileAttributes(pFileName,pAttributes)
  127. {
  128.    lReg.ah = 0x43;
  129.    lReg.al = 1;
  130.    lReg.cx = pAttributes;
  131.    if !defined(_DOS32_)
  132.       lReg.ds = segment(pFileName), lReg.dx = offset(pFileName);
  133.    else
  134.       lReg.dx = pointer(pFileName);
  135.    return interrupt(0x21,lReg);
  136. }
  137.  
  138. SetFileDateAndTime(pFileName,pTime)
  139. {
  140.    lSuccess = False;
  141.    // Open file to get a handle
  142.    lReg.ah = 0x3D;
  143.    lReg.al = 0x42;
  144.    if !defined(_DOS32_)
  145.       lReg.ds = segment(pFileName), lReg.dx = offset(pFileName);
  146.    else
  147.       lReg.dx = pointer(pFileName);
  148.    if ( interrupt(0x21,lReg,lRegout) ) {
  149.       lHandle = lRegout.ax;
  150.       // write date to file
  151.       undefine(lReg);
  152.       lReg.ah = 0x57;
  153.       lReg.al = 1;
  154.       lReg.bx = lHandle;
  155.       lTm = localtime(pTime);
  156.       lReg.cx = (lTm.tm_sec / 2)
  157.               | (lTm.tm_min << 5)
  158.               | (lTm.tm_hour << 11);
  159.       lReg.dx = lTm.tm_mday
  160.               | ((lTm.tm_mon+1) << 5)
  161.               | ((lTm.tm_year-80) << 9);
  162.       lSuccess = interrupt(0x21,lReg);
  163.       // close file
  164.       undefine(lReg);
  165.       lReg.ah = 0x3E;
  166.       lReg.bx = lHandle;
  167.       interrupt(0x21,lReg);
  168.    }
  169.    return lSuccess;
  170. }
  171.  
  172. #define GENERIC_WRITE 0x40000000
  173. #define FILE_SHARE_READ 0x01
  174. #define FILE_SHARE_WRITE 0x02
  175. #define OPEN_EXISTING 3
  176. #define INVALID_HANDLE_VALUE -1
  177.  
  178. mymkdir(pDirName) // no return value
  179. {
  180.    if defined(_OS2_) {
  181.       #define ORD_DOS32CREATEDIR 270
  182.       return !DynamicLink("doscalls",ORD_DOS32CREATEDIR,BIT32,CDECL,pDirName,0)
  183.    } else if ( defined(_NTCON_) || defined(_NTWIN_) ) {
  184.       return !DynamicLink("KERNEL32","CreateDirectoryA",STDCALL,pDirName,NULL);
  185.    } else if( defined(_NWNLM_) )
  186.    {
  187.      return mkdir(pDirName);
  188.    } else { // dos or windows use the same code
  189.     lReg.ah = 0x39;
  190.     if !defined(_DOS32_)
  191.        lReg.ds = segment(pDirName), lREg.dx = offset(pDirName);
  192.     else
  193.        lReg.dx = pointer(pDirName);
  194.     return !interrupt(0x21,lReg);
  195.    }
  196. }
  197.  
  198. /* ---------------------------------------------------------------------- */
  199.  
  200. /*
  201.  * Copy a single file. When done, set the time to the old file's time stamp.
  202.  */
  203. copy_file(target,source)
  204. {
  205.   if( (fp = fopen(source,"rb"))==NULL )
  206.     {
  207.       printf("Unable to open source file %s\n",source);
  208.       return;
  209.     }
  210.   if( (fp2 = fopen(target,"wb"))==NULL )
  211.     {
  212.       printf("Unable to open target file %s\n",target);
  213.       fclose(fp);
  214.       return;
  215.     }
  216.  
  217.   buffer = ""; SetArraySpan(buffer,1024);
  218.  
  219.   while( 1 )
  220.     {
  221.       num = fread(buffer,1024,fp);
  222.       if( num<1 ) break;
  223.       fwrite(buffer,num,fp2);
  224.     }
  225.  
  226.   fclose(fp2);
  227.   fclose(fp);
  228.  
  229.   dir = Directory(source);
  230.   if( dir==NULL || GetArraySpan(dir)!=0 )
  231.     {
  232.       printf("Error, can no longer open source file!\n");
  233.       return;
  234.     }
  235.  
  236.   new_attrib = dir[0].attrib;
  237.   if( turn_off_archived ) new_attrib &= ~_A_ARCH;
  238.  
  239.   if( defined(_NWNLM_) )
  240.     {
  241.       tempcreate[0] = DOSTimeFromCalendar(dir[0].Create);
  242.       tempaccess[0] = DOSTimeFromCalendar(dir[0].Access);
  243.       tempdate[0] =   DOSTimeFromCalendar(dir[0].Write);
  244.       tempbackup[0] = DOSTimeFromCalendar(dir[0].Backup);
  245.  
  246.       code = NLMLink("SetFileInfo",
  247.                  target,
  248.                  0x06,
  249.                  new_attrib,
  250.                  tempcreate,
  251.                  tempaccess,
  252.                  tempdate,
  253.                  tempbackup,
  254.                  dir[0].uid);
  255.  
  256.       if( code )
  257.         printf("\nError setting attributes for file %s\n",target);
  258.       return;
  259.     }
  260.   if( defined(_DOS_) || defined(_DOS32_) || defined(_WINDOWS_) )
  261.     {
  262.       SetFileDateAndTime(target,dir[0].Create);
  263.       SetFileAttributes(target,new_attrib);
  264.       return;
  265.     }
  266.   if( defined(_NTCON_) || defined(_NTWIN_) )
  267.     {
  268.       DynamicLink("KERNEL32","SetFileAttributesA",STDCALL,target,dir[0].attrib);
  269.  
  270.       createbuf = ""; SetArraySpan(createbuf,4);
  271.       accessbuf = ""; SetArraySpan(accessbuf,4);
  272.       writebuf = ""; SetArraySpan(writebuf,4);
  273.  
  274.       if( (handle = DynamicLink("KERNEL32","CreateFileA",STDCALL,target,
  275.                                 GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,
  276.                                 NULL,OPEN_EXISTING,0,NULL))
  277.          !=INVALID_HANDLE_VALUE)
  278.         {
  279.           dos = GMDOSTimeStructFromCalendar(dir[0].Create);
  280.           DynamicLink("KERNEL32","DosDateTimeToFileTime",STDCALL,
  281.                       dos.date,dos.time,createbuf);
  282.           dos = GMDOSTimeStructFromCalendar(dir[0].Access);
  283.           DynamicLink("KERNEL32","DosDateTimeToFileTime",STDCALL,
  284.                       dos.date,dos.time,accessbuf);
  285.           dos = GMDOSTimeStructFromCalendar(dir[0].Write);
  286.           DynamicLink("KERNEL32","DosDateTimeToFileTime",STDCALL,
  287.                       dos.date,dos.time,writebuf);
  288.  
  289.           if( !DynamicLink("KERNEL32","SetFileTime",STDCALL,handle,createbuf,
  290.                            accessbuf,writebuf) )
  291.             {
  292.               err = DynamicLink("KERNEL32","GetLastError",STDCALL);
  293.               printf("Unable to set new file time.\n",err);
  294.             }
  295.  
  296.           if( !DynamicLink("KERNEL32","CloseHandle",STDCALL,handle) )
  297.             printf("Unable to close the handle.\n");
  298.         } else {
  299.           printf("Unable to open the file to touch it.\n");
  300.         }
  301.       return;
  302.     }
  303.  
  304.   if( defined(_OS2_) || defined(_NTCON_) )
  305.     {
  306.       printf("I do not know how to set file attributes on this system.\n");
  307.       exit(EXIT_FAILURE);
  308.     }
  309. }
  310.  
  311. /* --------------------------------------------------------------------------- */
  312.  
  313. get_filename(source)
  314. {
  315.   filestruct = SplitFileName(source);
  316.   sprintf(newdir,"%s%s",filestruct.name,filestruct.ext);
  317.   return newdir;
  318. }
  319.  
  320.  
  321. /*
  322.  * Copy all files from the src directory to the tar directory. Silently create
  323.  * the target directory if it does not already exist. Use the global flags
  324.  * to determine whether to do subdirectories and what to do about special files.
  325.  */
  326. copy_dir(tar,src)
  327. {
  328.   printf("Copying directory %s...\n",FullPath(src));
  329.   may_have = 0x3f;
  330.   if( !copy_hidden ) may_have &= ~_A_HIDDEN;
  331.   if( !copy_system ) may_have &= ~_A_SYSTEM;
  332.   if( !copy_readonly )
  333.     {
  334.       may_have &= ~_A_RDONLY;
  335.       if( defined(_NWNLM_) ) may_have |= _A_NORENAM | _A_NODELET;
  336.     }
  337.   must_have = archived_only?_A_ARCH:0;
  338.  
  339.   strcpy(srcfiles,src);
  340.   if( defined(_NWNLM_) )
  341.     strcat(srcfiles,"/*.*");
  342.   else
  343.     strcat(srcfiles,"\\*.*");
  344.  
  345.   files = Directory(srcfiles,FALSE,may_have,must_have);
  346.   if( files==NULL && !empty ) return;
  347.  
  348.   mymkdir(tar);
  349.  
  350.   if( files==NULL ) return;
  351.  
  352.   for( i=0;i<=GetArraySpan(files);i++ )
  353.     {
  354.       if( files[i].attrib & _A_SUBDIR )
  355.         {
  356.           if( recursive )
  357.             {
  358.               strcpy(newname,tar);
  359.               if( newname[strlen(newname)-1]!='/' && newname[strlen(newname)-1]!='\\' )
  360.                 {
  361.                   if( defined(_NWNLM_) )
  362.                     strcat(newname,"/");
  363.                   else
  364.                     strcat(newname,"\\");
  365.                 }
  366.               strcat(newname,get_filename(files[i].name));
  367.               copy_dir(newname,files[i].name);
  368.             }
  369.         } else {
  370.           strcpy(newname,tar);
  371.           if( newname[strlen(newname)-1]!='/' && newname[strlen(newname)-1]!='\\' )
  372.             {
  373.               if( defined(_NWNLM_) )
  374.                 strcat(newname,"/");
  375.               else
  376.                 strcat(newname,"\\");
  377.             }
  378.           strcat(newname,get_filename(files[i].name));
  379.           copy_file(newname,files[i].name);
  380.         }
  381.     }
  382. }
  383.  
  384. /* --------------------------------------------------------------------------- */
  385.  
  386. main(argc,argv)
  387. {
  388.   parse_command_line(argc,argv);
  389.  
  390.   tar = Directory(target);
  391.   if( tar==NULL )
  392.     {
  393.       printf("The target does not exist. Assuming you wish to make a new directory\n");
  394.       printf("with that name...\n\n");
  395.       if( mymkdir(target) )
  396.         {
  397.           printf("Unable to make the specified directory.\n");
  398.           exit(1);
  399.         }
  400.     }
  401.     
  402.   copy_dir(target,source);
  403. }
  404.